car emulator and corrected srv

server/.gitignore

@@ -1,2 +1,3 @@
 .idea/workspace.xml
+.idea/uiDesigner.xml
 out

server/carEmulator/carEmulator.iml

@@ -9,5 +9,6 @@
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
     <orderEntry type="library" name="netty-all-4.1.2.Final-sources" level="project" />
+    <orderEntry type="library" name="protobuf-java-3.0.0-beta-3" level="project" />
   </component>
 </module>

server/carEmulator/src/CarEmulatorMain.kt

@@ -0,0 +1,79 @@
+import client.Client
+import io.netty.bootstrap.ServerBootstrap
+import io.netty.buffer.Unpooled
+import io.netty.channel.nio.NioEventLoopGroup
+import io.netty.channel.socket.nio.NioServerSocketChannel
+import io.netty.handler.codec.http.*
+import proto.car.ConnectP
+import proto.car.RouteDoneP
+import server.Initializer
+import java.util.*
+import kotlin.concurrent.thread
+
+/**
+ * Created by user on 7/6/16.
+ */
+
+
+val serverHost = "127.0.0.1"
+val serverPort = 7925
+val carHost = "127.0.0.1"
+
+val getLocationUrl = "getLocation"
+val routeDoneUrl = "routeDone"
+val setRouteUrl = "route"
+val connectUrl = "connect"
+
+fun main(args: Array<String>) {
+    val port = Random().nextInt(10000) + 10000
+    println("car started on port $port")
+
+    val serverCarThread = thread {
+        val bossGroup = NioEventLoopGroup(1)
+        val workerGroup = NioEventLoopGroup()
+        val b = ServerBootstrap()
+        b.group(bossGroup, workerGroup)
+                .channel(NioServerSocketChannel().javaClass)
+                .childHandler(Initializer())
+
+        try {
+            val channel = b.bind(port).sync().channel()
+            channel.closeFuture().sync()
+        } catch (e: InterruptedException) {
+            println("car server stoped!")
+            e.printStackTrace()
+        } finally {
+            bossGroup.shutdownGracefully()
+            workerGroup.shutdownGracefully()
+        }
+    }
+    //connect
+    val connect = ConnectP.ConnectionRequest.newBuilder().setIp(carHost).setPort(port).build()
+    val request = DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, connectUrl, Unpooled.copiedBuffer(connect.toByteArray()))
+    request.headers().set(HttpHeaderNames.HOST, serverHost)
+    request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
+    request.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, request.content().readableBytes())
+
+    Client.sendRequest(request, serverHost, serverPort)
+
+    val car = ThisCar.instance
+    var lastTime: Long = System.currentTimeMillis()
+    while (true) {
+        val deltaTimeMs = (System.currentTimeMillis() - lastTime)
+        if (deltaTimeMs > 50) {
+            if (!car.pathDone) {
+                println(car)
+            }
+            var pathDone = car.move(deltaTimeMs.toDouble()/ 1000)
+            if (pathDone) {
+                val routeDone = RouteDoneP.RouteDone.newBuilder().setUid(car.id).build()
+                val pathDoneRequest = DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, setRouteUrl, Unpooled.copiedBuffer(routeDone.toByteArray()))
+                pathDoneRequest.headers().set(HttpHeaderNames.HOST, serverHost)
+                pathDoneRequest.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
+                pathDoneRequest.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, pathDoneRequest.content().readableBytes())
+                Client.sendRequest(pathDoneRequest, serverHost, serverPort)
+            }
+            lastTime = System.currentTimeMillis()
+        }
+    }
+}

server/carEmulator/src/Main.kt

@@ -1,7 +0,0 @@
-/**
- * Created by user on 7/6/16.
- */
-
-fun main(args: Array<String>) {
-    println("test")
-}

server/carEmulator/src/ThisCar.kt

@@ -0,0 +1,95 @@
+import client.Client
+import io.netty.buffer.Unpooled
+import io.netty.handler.codec.http.*
+import proto.car.RouteDoneP
+import proto.car.RouteP.Route.WayPoint
+
+/**
+ * Created by user on 7/8/16.
+ */
+class ThisCar private constructor() {
+
+    var id = ""
+
+
+    //metr
+    var x: Double = 0.toDouble()
+    var y: Double = 0.toDouble()
+
+    //Degree
+    var angle: Double = 0.toDouble();//0 - положительное направление по OX
+
+    val velocityMove: Double = 0.1//metr/sec
+    val velocityRotation: Double = 10.toDouble()//Degree/sec
+
+    val wayPoints: MutableList<WayPoint> = mutableListOf()
+    var nextWayPointIndex = 0
+    var pathDone = true
+
+    var distanceToNext: Double = 0.toDouble()
+    var angleToNext: Double = 0.toDouble()
+    var anglePositive = true//true - поворот по часовой, false - против
+
+    companion object {
+
+        val instance = ThisCar()
+    }
+
+
+    @Synchronized
+    fun move(deltaTime: Double) :Boolean {
+        if (pathDone) {
+            //маршрут не задан и сервер "в курсе", что маршрут пройден
+            return false;
+        }
+        if (distanceToNext > 0 || angleToNext > 0) {
+            if (angleToNext > 0) {
+                //поворачиваемся
+                val angleDelta: Double = velocityRotation * deltaTime
+
+                angle += (if (anglePositive) 1 else -1) * angleDelta
+                angleToNext -= angleDelta
+                if (angleToNext < 0) {
+                    angleToNext = 0.toDouble()
+                }
+            } else {
+                //машинка повернута в нужную сторону, можно ехать
+                var xDelta = deltaTime * velocityMove * Math.cos(angle * Math.PI / 180)
+                var yDelta = deltaTime * velocityMove * Math.sin(angle * Math.PI / 180)
+                x += xDelta
+                y += yDelta
+                distanceToNext -= deltaTime * velocityMove
+                if (distanceToNext < 0) {
+                    distanceToNext = 0.toDouble()
+                }
+            }
+        } else if (nextWayPointIndex == wayPoints.size) {
+            pathDone = true
+            return true;
+        } else {
+            val wayPoint = wayPoints.get(nextWayPointIndex)
+            angleToNext = Math.abs(wayPoint.angleDelta)
+            distanceToNext = Math.abs(wayPoint.distance)//задний ход пока отключаем:)
+            anglePositive = (wayPoint.angleDelta > 0)
+            nextWayPointIndex++
+        }
+        return false;
+
+
+    }
+
+    @Synchronized
+    fun setPath(wayPoints: List<WayPoint>) {
+        println("in set path")
+        this.pathDone = false
+        distanceToNext = 0.toDouble()
+        angleToNext = 0.toDouble()
+        nextWayPointIndex = 0
+        this.wayPoints.clear()
+        this.wayPoints.addAll(wayPoints)
+    }
+
+    override fun toString(): String {
+        return "x:$x; y:$y; angle:$angle"
+    }
+}

server/carEmulator/src/client/Client.kt

@@ -0,0 +1,40 @@
+package client
+
+import io.netty.bootstrap.Bootstrap
+import io.netty.channel.ChannelInitializer
+import io.netty.channel.nio.NioEventLoopGroup
+import io.netty.channel.socket.SocketChannel
+import io.netty.channel.socket.nio.NioSocketChannel
+import io.netty.handler.codec.http.HttpRequest
+import io.netty.util.AttributeKey
+
+/**
+ * Created by user on 7/8/16.
+ */
+object Client {
+
+    val bootstrap: Bootstrap = makeBootstrap()
+
+    private fun makeBootstrap(): Bootstrap {
+        val group = NioEventLoopGroup();
+        val b = Bootstrap();
+        b.group(group).channel(NioSocketChannel().javaClass).handler(ClientInitializer())
+                .attr(AttributeKey.newInstance<String>("url"), "")
+                .attr(AttributeKey.newInstance<String>("uid"), "")
+        return b
+    }
+
+    fun sendRequest(request: HttpRequest, host: String, port: Int) {
+        try {
+            bootstrap.attr(AttributeKey.valueOf<String>("url"), request.uri())
+            //            bootstrap.attr(AttributeKey.valueOf<String>("uid"), carUid)
+            val ch = bootstrap.connect(host, port).sync().channel()
+            ch.writeAndFlush(request)
+            ch.closeFuture().sync()//wait for answer
+            //            val handler: ClientHandler = ch.pipeline().get(ClientHandler().javaClass)
+        } catch (e: InterruptedException) {
+
+        }
+    }
+
+}

server/carEmulator/src/client/ClientHandler.kt

@@ -0,0 +1,62 @@
+package client
+
+import com.google.protobuf.InvalidProtocolBufferException
+import connectUrl
+import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.SimpleChannelInboundHandler
+import io.netty.handler.codec.http.DefaultHttpContent
+import io.netty.handler.codec.http.HttpContent
+import io.netty.handler.codec.http.HttpRequest
+import io.netty.handler.codec.http.HttpResponse
+import io.netty.util.AttributeKey
+import proto.car.ConnectP
+
+/**
+ * Created by user on 7/8/16.
+ */
+class ClientHandler : SimpleChannelInboundHandler<Any> {
+
+    constructor()
+
+    var url: String = ""
+    var contentBytes: ByteArray = ByteArray(0);
+
+
+    override fun channelReadComplete(ctx: ChannelHandlerContext) {
+
+        val url = ctx.channel().attr(AttributeKey.valueOf<String>("url")).get()
+
+        when (url) {
+            connectUrl -> {
+                try {
+                    val uid = ConnectP.ConnectionResponse.parseFrom(contentBytes).uid
+                    synchronized(ThisCar.instance, {
+                        ThisCar.instance.id = uid;
+                    })
+                } catch (e: InvalidProtocolBufferException) {
+                    e.printStackTrace()
+                }
+            }
+            else -> {
+                //todo error
+            }
+        }
+        ctx.close()
+    }
+
+    override fun channelRead(ctx: ChannelHandlerContext?, msg: Any?) {
+        super.channelRead(ctx, msg)
+    }
+
+    override fun channelRead0(ctx: ChannelHandlerContext?, msg: Any?) {
+        if (msg is HttpResponse) {
+            //            this.url = msg.uri()
+        }
+
+        if (msg is HttpContent) {
+            val contentsBytes = msg.content();
+            contentBytes = ByteArray(contentsBytes.capacity())
+            contentsBytes.readBytes(contentBytes)
+        }
+    }
+}

server/carEmulator/src/client/ClientInitializer.kt

@@ -0,0 +1,19 @@
+package client
+
+import io.netty.channel.ChannelInitializer
+import io.netty.channel.socket.SocketChannel
+import io.netty.handler.codec.http.HttpClientCodec
+
+/**
+ * Created by user on 7/8/16.
+ */
+class ClientInitializer : ChannelInitializer<SocketChannel> {
+
+    constructor()
+
+    override fun initChannel(ch: SocketChannel) {
+        val p = ch.pipeline()
+        p.addLast(HttpClientCodec())
+        p.addLast(ClientHandler())
+    }
+}

server/carEmulator/src/proto/car/LocationP.java

@@ -0,0 +1,540 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: location.proto
+
+package proto.car;
+
+public final class LocationP {
+  private LocationP() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+  }
+  public interface LocationOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:carkot.Location)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * <code>optional double x = 1;</code>
+     */
+    double getX();
+
+    /**
+     * <code>optional double y = 2;</code>
+     */
+    double getY();
+
+    /**
+     * <code>optional double angle = 3;</code>
+     */
+    double getAngle();
+  }
+  /**
+   * Protobuf type {@code carkot.Location}
+   */
+  public  static final class Location extends
+      com.google.protobuf.GeneratedMessage implements
+      // @@protoc_insertion_point(message_implements:carkot.Location)
+      LocationOrBuilder {
+    // Use Location.newBuilder() to construct.
+    private Location(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+    }
+    private Location() {
+      x_ = 0D;
+      y_ = 0D;
+      angle_ = 0D;
+    }
+
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+    getUnknownFields() {
+      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
+    }
+    private Location(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      this();
+      int mutable_bitField0_ = 0;
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!input.skipField(tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 9: {
+
+              x_ = input.readDouble();
+              break;
+            }
+            case 17: {
+
+              y_ = input.readDouble();
+              break;
+            }
+            case 25: {
+
+              angle_ = input.readDouble();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e).setUnfinishedMessage(this);
+      } finally {
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return proto.car.LocationP.internal_static_carkot_Location_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return proto.car.LocationP.internal_static_carkot_Location_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              proto.car.LocationP.Location.class, proto.car.LocationP.Location.Builder.class);
+    }
+
+    public static final int X_FIELD_NUMBER = 1;
+    private double x_;
+    /**
+     * <code>optional double x = 1;</code>
+     */
+    public double getX() {
+      return x_;
+    }
+
+    public static final int Y_FIELD_NUMBER = 2;
+    private double y_;
+    /**
+     * <code>optional double y = 2;</code>
+     */
+    public double getY() {
+      return y_;
+    }
+
+    public static final int ANGLE_FIELD_NUMBER = 3;
+    private double angle_;
+    /**
+     * <code>optional double angle = 3;</code>
+     */
+    public double getAngle() {
+      return angle_;
+    }
+
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      if (x_ != 0D) {
+        output.writeDouble(1, x_);
+      }
+      if (y_ != 0D) {
+        output.writeDouble(2, y_);
+      }
+      if (angle_ != 0D) {
+        output.writeDouble(3, angle_);
+      }
+    }
+
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (x_ != 0D) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeDoubleSize(1, x_);
+      }
+      if (y_ != 0D) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeDoubleSize(2, y_);
+      }
+      if (angle_ != 0D) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeDoubleSize(3, angle_);
+      }
+      memoizedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    public static proto.car.LocationP.Location parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static proto.car.LocationP.Location parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static proto.car.LocationP.Location parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static proto.car.LocationP.Location parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static proto.car.LocationP.Location parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseWithIOException(PARSER, input);
+    }
+    public static proto.car.LocationP.Location parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static proto.car.LocationP.Location parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+    public static proto.car.LocationP.Location parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static proto.car.LocationP.Location parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseWithIOException(PARSER, input);
+    }
+    public static proto.car.LocationP.Location parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(proto.car.LocationP.Location prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code carkot.Location}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder> implements
+        // @@protoc_insertion_point(builder_implements:carkot.Location)
+        proto.car.LocationP.LocationOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return proto.car.LocationP.internal_static_carkot_Location_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return proto.car.LocationP.internal_static_carkot_Location_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                proto.car.LocationP.Location.class, proto.car.LocationP.Location.Builder.class);
+      }
+
+      // Construct using proto.car.LocationP.Location.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      public Builder clear() {
+        super.clear();
+        x_ = 0D;
+
+        y_ = 0D;
+
+        angle_ = 0D;
+
+        return this;
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return proto.car.LocationP.internal_static_carkot_Location_descriptor;
+      }
+
+      public proto.car.LocationP.Location getDefaultInstanceForType() {
+        return proto.car.LocationP.Location.getDefaultInstance();
+      }
+
+      public proto.car.LocationP.Location build() {
+        proto.car.LocationP.Location result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public proto.car.LocationP.Location buildPartial() {
+        proto.car.LocationP.Location result = new proto.car.LocationP.Location(this);
+        result.x_ = x_;
+        result.y_ = y_;
+        result.angle_ = angle_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof proto.car.LocationP.Location) {
+          return mergeFrom((proto.car.LocationP.Location)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(proto.car.LocationP.Location other) {
+        if (other == proto.car.LocationP.Location.getDefaultInstance()) return this;
+        if (other.getX() != 0D) {
+          setX(other.getX());
+        }
+        if (other.getY() != 0D) {
+          setY(other.getY());
+        }
+        if (other.getAngle() != 0D) {
+          setAngle(other.getAngle());
+        }
+        onChanged();
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        proto.car.LocationP.Location parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (proto.car.LocationP.Location) e.getUnfinishedMessage();
+          throw e.unwrapIOException();
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+
+      private double x_ ;
+      /**
+       * <code>optional double x = 1;</code>
+       */
+      public double getX() {
+        return x_;
+      }
+      /**
+       * <code>optional double x = 1;</code>
+       */
+      public Builder setX(double value) {
+        
+        x_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional double x = 1;</code>
+       */
+      public Builder clearX() {
+        
+        x_ = 0D;
+        onChanged();
+        return this;
+      }
+
+      private double y_ ;
+      /**
+       * <code>optional double y = 2;</code>
+       */
+      public double getY() {
+        return y_;
+      }
+      /**
+       * <code>optional double y = 2;</code>
+       */
+      public Builder setY(double value) {
+        
+        y_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional double y = 2;</code>
+       */
+      public Builder clearY() {
+        
+        y_ = 0D;
+        onChanged();
+        return this;
+      }
+
+      private double angle_ ;
+      /**
+       * <code>optional double angle = 3;</code>
+       */
+      public double getAngle() {
+        return angle_;
+      }
+      /**
+       * <code>optional double angle = 3;</code>
+       */
+      public Builder setAngle(double value) {
+        
+        angle_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional double angle = 3;</code>
+       */
+      public Builder clearAngle() {
+        
+        angle_ = 0D;
+        onChanged();
+        return this;
+      }
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return this;
+      }
+
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return this;
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:carkot.Location)
+    }
+
+    // @@protoc_insertion_point(class_scope:carkot.Location)
+    private static final proto.car.LocationP.Location DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new proto.car.LocationP.Location();
+    }
+
+    public static proto.car.LocationP.Location getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser<Location>
+        PARSER = new com.google.protobuf.AbstractParser<Location>() {
+      public Location parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+          return new Location(input, extensionRegistry);
+      }
+    };
+
+    public static com.google.protobuf.Parser<Location> parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<Location> getParserForType() {
+      return PARSER;
+    }
+
+    public proto.car.LocationP.Location getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  private static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_carkot_Location_descriptor;
+  private static final 
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_carkot_Location_fieldAccessorTable;
+
+  public static com.google.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static  com.google.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n\016location.proto\022\006carkot\"/\n\010Location\022\t\n\001" +
+      "x\030\001 \001(\001\022\t\n\001y\030\002 \001(\001\022\r\n\005angle\030\003 \001(\001B\026\n\tpro" +
+      "to.carB\tLocationPb\006proto3"
+    };
+    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
+          public com.google.protobuf.ExtensionRegistry assignDescriptors(
+              com.google.protobuf.Descriptors.FileDescriptor root) {
+            descriptor = root;
+            return null;
+          }
+        };
+    com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+        }, assigner);
+    internal_static_carkot_Location_descriptor =
+      getDescriptor().getMessageTypes().get(0);
+    internal_static_carkot_Location_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+        internal_static_carkot_Location_descriptor,
+        new java.lang.String[] { "X", "Y", "Angle", });
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}

server/carEmulator/src/proto/car/RouteDoneP.java

@@ -0,0 +1,496 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: routeDone.proto
+
+package proto.car;
+
+public final class RouteDoneP {
+  private RouteDoneP() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+  }
+  public interface RouteDoneOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:carkot.RouteDone)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * <code>optional string uid = 1;</code>
+     */
+    java.lang.String getUid();
+    /**
+     * <code>optional string uid = 1;</code>
+     */
+    com.google.protobuf.ByteString
+        getUidBytes();
+  }
+  /**
+   * Protobuf type {@code carkot.RouteDone}
+   */
+  public  static final class RouteDone extends
+      com.google.protobuf.GeneratedMessage implements
+      // @@protoc_insertion_point(message_implements:carkot.RouteDone)
+      RouteDoneOrBuilder {
+    // Use RouteDone.newBuilder() to construct.
+    private RouteDone(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+    }
+    private RouteDone() {
+      uid_ = "";
+    }
+
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+    getUnknownFields() {
+      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
+    }
+    private RouteDone(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      this();
+      int mutable_bitField0_ = 0;
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!input.skipField(tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              java.lang.String s = input.readStringRequireUtf8();
+
+              uid_ = s;
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e).setUnfinishedMessage(this);
+      } finally {
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return proto.car.RouteDoneP.internal_static_carkot_RouteDone_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return proto.car.RouteDoneP.internal_static_carkot_RouteDone_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              proto.car.RouteDoneP.RouteDone.class, proto.car.RouteDoneP.RouteDone.Builder.class);
+    }
+
+    public static final int UID_FIELD_NUMBER = 1;
+    private volatile java.lang.Object uid_;
+    /**
+     * <code>optional string uid = 1;</code>
+     */
+    public java.lang.String getUid() {
+      java.lang.Object ref = uid_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        uid_ = s;
+        return s;
+      }
+    }
+    /**
+     * <code>optional string uid = 1;</code>
+     */
+    public com.google.protobuf.ByteString
+        getUidBytes() {
+      java.lang.Object ref = uid_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        uid_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      if (!getUidBytes().isEmpty()) {
+        com.google.protobuf.GeneratedMessage.writeString(output, 1, uid_);
+      }
+    }
+
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (!getUidBytes().isEmpty()) {
+        size += com.google.protobuf.GeneratedMessage.computeStringSize(1, uid_);
+      }
+      memoizedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    public static proto.car.RouteDoneP.RouteDone parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static proto.car.RouteDoneP.RouteDone parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static proto.car.RouteDoneP.RouteDone parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static proto.car.RouteDoneP.RouteDone parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static proto.car.RouteDoneP.RouteDone parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseWithIOException(PARSER, input);
+    }
+    public static proto.car.RouteDoneP.RouteDone parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static proto.car.RouteDoneP.RouteDone parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+    public static proto.car.RouteDoneP.RouteDone parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static proto.car.RouteDoneP.RouteDone parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseWithIOException(PARSER, input);
+    }
+    public static proto.car.RouteDoneP.RouteDone parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessage
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(proto.car.RouteDoneP.RouteDone prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code carkot.RouteDone}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder> implements
+        // @@protoc_insertion_point(builder_implements:carkot.RouteDone)
+        proto.car.RouteDoneP.RouteDoneOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return proto.car.RouteDoneP.internal_static_carkot_RouteDone_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return proto.car.RouteDoneP.internal_static_carkot_RouteDone_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                proto.car.RouteDoneP.RouteDone.class, proto.car.RouteDoneP.RouteDone.Builder.class);
+      }
+
+      // Construct using proto.car.RouteDoneP.RouteDone.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      public Builder clear() {
+        super.clear();
+        uid_ = "";
+
+        return this;
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return proto.car.RouteDoneP.internal_static_carkot_RouteDone_descriptor;
+      }
+
+      public proto.car.RouteDoneP.RouteDone getDefaultInstanceForType() {
+        return proto.car.RouteDoneP.RouteDone.getDefaultInstance();
+      }
+
+      public proto.car.RouteDoneP.RouteDone build() {
+        proto.car.RouteDoneP.RouteDone result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public proto.car.RouteDoneP.RouteDone buildPartial() {
+        proto.car.RouteDoneP.RouteDone result = new proto.car.RouteDoneP.RouteDone(this);
+        result.uid_ = uid_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof proto.car.RouteDoneP.RouteDone) {
+          return mergeFrom((proto.car.RouteDoneP.RouteDone)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(proto.car.RouteDoneP.RouteDone other) {
+        if (other == proto.car.RouteDoneP.RouteDone.getDefaultInstance()) return this;
+        if (!other.getUid().isEmpty()) {
+          uid_ = other.uid_;
+          onChanged();
+        }
+        onChanged();
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        proto.car.RouteDoneP.RouteDone parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (proto.car.RouteDoneP.RouteDone) e.getUnfinishedMessage();
+          throw e.unwrapIOException();
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+
+      private java.lang.Object uid_ = "";
+      /**
+       * <code>optional string uid = 1;</code>
+       */
+      public java.lang.String getUid() {
+        java.lang.Object ref = uid_;
+        if (!(ref instanceof java.lang.String)) {
+          com.google.protobuf.ByteString bs =
+              (com.google.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          uid_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string uid = 1;</code>
+       */
+      public com.google.protobuf.ByteString
+          getUidBytes() {
+        java.lang.Object ref = uid_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          uid_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string uid = 1;</code>
+       */
+      public Builder setUid(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  
+        uid_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string uid = 1;</code>
+       */
+      public Builder clearUid() {
+        
+        uid_ = getDefaultInstance().getUid();
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional string uid = 1;</code>
+       */
+      public Builder setUidBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  checkByteStringIsUtf8(value);
+        
+        uid_ = value;
+        onChanged();
+        return this;
+      }
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return this;
+      }
+
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return this;
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:carkot.RouteDone)
+    }
+
+    // @@protoc_insertion_point(class_scope:carkot.RouteDone)
+    private static final proto.car.RouteDoneP.RouteDone DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new proto.car.RouteDoneP.RouteDone();
+    }
+
+    public static proto.car.RouteDoneP.RouteDone getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser<RouteDone>
+        PARSER = new com.google.protobuf.AbstractParser<RouteDone>() {
+      public RouteDone parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+          return new RouteDone(input, extensionRegistry);
+      }
+    };
+
+    public static com.google.protobuf.Parser<RouteDone> parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<RouteDone> getParserForType() {
+      return PARSER;
+    }
+
+    public proto.car.RouteDoneP.RouteDone getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  private static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_carkot_RouteDone_descriptor;
+  private static final 
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_carkot_RouteDone_fieldAccessorTable;
+
+  public static com.google.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static  com.google.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n\017routeDone.proto\022\006carkot\"\030\n\tRouteDone\022\013" +
+      "\n\003uid\030\001 \001(\tB\027\n\tproto.carB\nRouteDonePb\006pr" +
+      "oto3"
+    };
+    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
+          public com.google.protobuf.ExtensionRegistry assignDescriptors(
+              com.google.protobuf.Descriptors.FileDescriptor root) {
+            descriptor = root;
+            return null;
+          }
+        };
+    com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+        }, assigner);
+    internal_static_carkot_RouteDone_descriptor =
+      getDescriptor().getMessageTypes().get(0);
+    internal_static_carkot_RouteDone_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+        internal_static_carkot_RouteDone_descriptor,
+        new java.lang.String[] { "Uid", });
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}

server/carEmulator/src/server/Handler.kt

@@ -1,5 +1,6 @@
 package server
 
+import com.google.protobuf.InvalidProtocolBufferException
 import connectUrl
 import getLocationUrl
 import io.netty.buffer.Unpooled
@@ -7,67 +8,66 @@ import io.netty.channel.ChannelFutureListener
 import io.netty.channel.ChannelHandlerContext
 import io.netty.channel.SimpleChannelInboundHandler
 import io.netty.handler.codec.http.*
-import io.netty.util.CharsetUtil
-import objects.Environment
 import proto.car.ConnectP.ConnectionRequest
-import proto.car.RouteDoneP
+import proto.car.LocationP
 import proto.car.RouteDoneP.RouteDone
+import proto.car.RouteP
 import routeDoneUrl
 import setRouteUrl
-import java.nio.charset.Charset
-import java.text.SimpleDateFormat
 import java.util.*
 
 /**
  * Created by user on 7/6/16.
  */
-class ServerHandler : SimpleChannelInboundHandler<Any>() {
+class Handler : SimpleChannelInboundHandler<Any>() {
 
     var url: String = ""
     var contentBytes: ByteArray = ByteArray(0);
 
     override fun channelReadComplete(ctx: ChannelHandlerContext) {
 
-        val environment = Environment.instance
+        val car = ThisCar.instance
         var success = true;
+
+        var dataAnswer: ByteArray = ByteArray(0)
         when (url) {
-            connectUrl -> {
+            getLocationUrl -> {
-                val data = ConnectionRequest.parseFrom(contentBytes)
+                dataAnswer = LocationP.Location.newBuilder().setAngle(car.angle).setX(car.x).setY(car.y).build().toByteArray();
-                //todo
             }
-            routeDoneUrl -> {
+            setRouteUrl -> {
-                val data = RouteDone.parseFrom(contentBytes)
+                var data: RouteP.Route? = null;
-                val id = data.uid
+                try {
-                synchronized(environment.map, {
+                    data = RouteP.Route.parseFrom(contentBytes)
-                    val car = environment.map.get(id)
+                } catch (e: InvalidProtocolBufferException) {
-                    if (car != null) {
+                    //todo error answer
-                        car.free = true
+                }
-                    } else {
+                if (data != null) {
-                        success = false
+                    val wayPoints = data.wayPointsList
-                    }
+                    println("try set path")
-                })
+                    ThisCar.instance.setPath(wayPoints)
+                }
             }
             else -> {
                 success = false
-                //todo unsup operation
+                //todo unsup operation. error answer
             }
         }
 
-        val response = DefaultFullHttpResponse(HttpVersion.HTTP_1_1, if (success) HttpResponseStatus.OK else HttpResponseStatus.NOT_FOUND)
+        val response = DefaultFullHttpResponse(HttpVersion.HTTP_1_1, if (success) HttpResponseStatus.OK else HttpResponseStatus.NOT_FOUND, Unpooled.copiedBuffer(dataAnswer))
         response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, response.content().readableBytes())
         ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
     }
 
+    override fun channelRead(ctx: ChannelHandlerContext?, msg: Any?) {
+        super.channelRead(ctx, msg)
+    }
+
     override fun channelRead0(ctx: ChannelHandlerContext, msg: Any) {
         if (msg is HttpRequest) {
             this.url = msg.uri()
-//            sb.append("" + msg.method() + " " + msg.protocolVersion() + "\n" + msg.uri())
-//            for (header in msg.headers()) {
-//                sb.append(header.key + ":" + header.value + "\n")
-//            }
         }
 
-        if (msg is DefaultHttpContent) {
+        if (msg is HttpContent) {
             val contentsBytes = msg.content();
             contentBytes = ByteArray(contentsBytes.capacity())
             contentsBytes.readBytes(contentBytes)

server/carEmulator/src/server/Initializer.kt

@@ -0,0 +1,29 @@
+package server
+
+import io.netty.channel.ChannelInitializer
+import io.netty.channel.ChannelPipeline
+import io.netty.channel.socket.SocketChannel
+import io.netty.handler.codec.http.HttpRequestDecoder
+import io.netty.handler.codec.http.HttpResponseEncoder
+import io.netty.handler.codec.http.HttpServerCodec
+import io.netty.util.concurrent.DefaultEventExecutorGroup
+import io.netty.util.concurrent.EventExecutorGroup
+
+/**
+ * Created by user on 7/6/16.
+ */
+class Initializer : ChannelInitializer<SocketChannel> {
+
+
+    constructor() {
+    }
+
+    override fun initChannel(channel: SocketChannel) {
+        val p: ChannelPipeline = channel.pipeline()
+
+        p.addLast(HttpServerCodec())
+//        p.addLast(HttpRequestDecoder())
+//        p.addLast(HttpResponseEncoder())
+        p.addLast(Handler())
+    }
+}

server/src/Main.kt

@@ -1,23 +0,0 @@
-import server.Server
-import java.awt.Robot
-import java.util.*
-import kotlin.concurrent.thread
-import kotlin.jvm.internal.iterator
-
-/**
- * Created by user on 7/6/16.
- */
-
-//хардкод это плохо, но пока так...:)
-val port:Int = 7925
-val handlerThreadsCount:Int = 100
-val getLocationUrl = "getLocation"
-val routeDoneUrl = "routeDone"
-val setRouteUrl = "route"
-val connectUrl = "connect"
-
-fun main(args: Array<String>) {
-    println("server started")
-    val server = Server(port, handlerThreadsCount)
-    val serverThread = thread{server.run()}
-}

server/src/ServerMain.kt

@@ -0,0 +1,116 @@
+import car.client.Client
+import io.netty.bootstrap.ServerBootstrap
+import io.netty.buffer.Unpooled
+import io.netty.channel.nio.NioEventLoopGroup
+import io.netty.channel.socket.nio.NioServerSocketChannel
+import io.netty.handler.codec.http.*
+import objects.Car
+import proto.car.RouteP
+import java.util.*
+import kotlin.concurrent.thread
+
+/**
+ * Created by user on 7/6/16.
+ */
+
+//хардкод это плохо, но пока так...:)
+val carServerPort: Int = 7925
+val webServerPort: Int = 7926
+val handlerThreadsCount: Int = 100
+val getLocationUrl = "getLocation"
+val routeDoneUrl = "routeDone"
+val setRouteUrl = "route"
+val connectUrl = "connect"
+
+fun main(args: Array<String>) {
+
+    println("car server started")
+    val serverCarThread = thread {
+        val bossGroup = NioEventLoopGroup(1)
+        val workerGroup = NioEventLoopGroup()
+        val b = ServerBootstrap()
+        b.group(bossGroup, workerGroup)
+                .channel(NioServerSocketChannel().javaClass)
+                .childHandler(car.server.Initializer(handlerThreadsCount))
+
+        try {
+            val channel = b.bind(carServerPort).sync().channel()
+            channel.closeFuture().sync()
+        } catch (e: InterruptedException) {
+            println("car server stoped!")
+            e.printStackTrace()
+        } finally {
+            bossGroup.shutdownGracefully()
+            workerGroup.shutdownGracefully()
+        }
+    }
+
+    //    val serverWebThread = thread {
+    //        val bossGroup = NioEventLoopGroup(1)
+    //        val workerGroup = NioEventLoopGroup()
+    //        val b = ServerBootstrap()
+    //        b.group(bossGroup, workerGroup)
+    //                .channel(NioServerSocketChannel().javaClass)
+    //                .childHandler(web.server.Initializer(handlerThreadsCount))
+    //
+    //        try {
+    //            val channel = b.bind(webServerPort).sync().channel()
+    //            channel.closeFuture().sync()
+    //        } catch (e: InterruptedException) {
+    //            println("web server stoped!")
+    //        } finally {
+    //            bossGroup.shutdownGracefully()
+    //            workerGroup.shutdownGracefully()
+    //        }
+    //    }
+    val serverWebThread = thread {
+        val environment = objects.Environment.instance
+        val scanner = Scanner(System.`in`)
+        while (scanner.hasNext()) {
+            val s = scanner.nextLine()
+            if (s.equals("cars", true)) {
+                synchronized(environment, {
+                    println(environment.map.values)
+                })
+            } else if (s.equals("pathto", true)) {
+                println("print datas. format: [string id] [double distance] [double angle]")
+                val data = scanner.nextLine()
+                val datas = data.split(" ")
+                try {
+                    val id = datas[0]
+                    val distance = datas[1].toDouble()
+                    val angle = datas[2].toDouble()
+
+                    val car: Car? =
+                            synchronized(environment, {
+                                environment.map.get(id)
+                            })
+                    if (car != null) {
+                        val wayPoint = RouteP.Route.WayPoint.newBuilder().setDistance(distance).setAngleDelta(angle).build()
+                        val route = RouteP.Route.newBuilder().addWayPoints(wayPoint).build()
+                        val request = DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, setRouteUrl, Unpooled.copiedBuffer(route.toByteArray()))
+                        request.headers().set(HttpHeaderNames.HOST, car.host)
+                        request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
+                        request.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, request.content().readableBytes())
+                        Client.sendRequest(request, car.host, car.port, id)
+                    }
+
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    println("incorrect format")
+                }
+            } else if (s.equals("refloc", true)) {
+                val cars = synchronized(environment, {environment.map.values})
+                for (car in cars) {
+                    val request = DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, getLocationUrl, Unpooled.EMPTY_BUFFER)
+                    request.headers().set(HttpHeaderNames.HOST, car.host)
+                    request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE)
+                    request.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, request.content().readableBytes())
+                    Client.sendRequest(request, car.host, car.port, car.id)
+                }
+            }
+        }
+    }
+
+
+}

server/src/car/client/Client.kt

@@ -0,0 +1,40 @@
+package car.client
+
+import io.netty.bootstrap.Bootstrap
+import io.netty.channel.ChannelFutureListener
+import io.netty.channel.ChannelInitializer
+import io.netty.channel.nio.NioEventLoopGroup
+import io.netty.channel.socket.SocketChannel
+import io.netty.channel.socket.nio.NioSocketChannel
+import io.netty.handler.codec.http.HttpRequest
+import io.netty.util.AttributeKey
+
+/**
+ * Created by user on 7/8/16.
+ */
+object Client {
+
+    val bootstrap: Bootstrap = makeBootstrap()
+
+    private fun makeBootstrap(): Bootstrap {
+        val group = NioEventLoopGroup();
+        val b = Bootstrap();
+        b.group(group).channel(NioSocketChannel().javaClass).handler(ClientInitializer())
+                .attr(AttributeKey.newInstance<String>("url"), "")
+                .attr(AttributeKey.newInstance<String>("uid"), "")
+        return b
+    }
+
+    fun sendRequest(request: HttpRequest, host: String, port: Int, carUid: String) {
+        try {
+            bootstrap.attr(AttributeKey.valueOf<String>("url"), request.uri())
+            bootstrap.attr(AttributeKey.valueOf<String>("uid"), carUid)
+            val ch = bootstrap.connect(host, port).sync().channel()
+            ch.writeAndFlush(request)
+            ch.closeFuture().sync()//wait for answer
+        } catch (e: InterruptedException) {
+
+        }
+    }
+
+}

server/src/car/client/ClientHandler.kt

@@ -0,0 +1,60 @@
+package car.client
+
+import com.google.protobuf.InvalidProtocolBufferException
+import getLocationUrl
+import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.SimpleChannelInboundHandler
+import io.netty.handler.codec.http.HttpContent
+import io.netty.util.AttributeKey
+import objects.Environment
+import proto.car.LocationP
+import setRouteUrl
+import java.util.*
+
+/**
+ * Created by user on 7/8/16.
+ */
+class ClientHandler : SimpleChannelInboundHandler<Any> {
+
+    constructor()
+
+    var contentBytes: ByteArray = ByteArray(0);
+
+    override fun channelReadComplete(ctx: ChannelHandlerContext) {
+        val url = ctx.channel().attr(AttributeKey.valueOf<String>("url")).get()
+        val carUid = ctx.channel().attr(AttributeKey.valueOf<String>("uid")).get()
+        val environment = Environment.instance
+        when (url) {
+            setRouteUrl -> {
+
+            }
+            getLocationUrl -> {
+
+                try {
+                    val data = LocationP.Location.parseFrom(contentBytes)
+                    synchronized(environment, {
+                        val car = environment.map.get(carUid)
+                        if (car != null) {
+                            car.x = data.x
+                            car.y = data.y
+                        }
+                    })
+                } catch (e: InvalidProtocolBufferException) {
+                    //todo error answer
+                }
+            }
+            else -> {
+
+            }
+        }
+        ctx.close()
+    }
+
+    override fun channelRead0(ctx: ChannelHandlerContext?, msg: Any?) {
+        if (msg is HttpContent) {
+            val contentsBytes = msg.content();
+            contentBytes = ByteArray(contentsBytes.capacity())
+            contentsBytes.readBytes(contentBytes)
+        }
+    }
+}

server/src/car/client/ClientInitializer.kt

@@ -0,0 +1,19 @@
+package car.client
+
+import io.netty.channel.ChannelInitializer
+import io.netty.channel.socket.SocketChannel
+import io.netty.handler.codec.http.HttpClientCodec
+
+/**
+ * Created by user on 7/8/16.
+ */
+class ClientInitializer : ChannelInitializer<SocketChannel> {
+
+    constructor()
+
+    override fun initChannel(ch: SocketChannel) {
+        val p = ch.pipeline()
+        p.addLast(HttpClientCodec())
+        p.addLast(ClientHandler())
+    }
+}

server/src/car/server/Handler.kt

@@ -0,0 +1,95 @@
+package car.server
+
+import com.google.protobuf.InvalidProtocolBufferException
+import connectUrl
+import io.netty.buffer.Unpooled
+import io.netty.channel.ChannelFutureListener
+import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.SimpleChannelInboundHandler
+import io.netty.handler.codec.http.*
+import objects.Car
+import objects.Environment
+import proto.car.ConnectP
+import proto.car.ConnectP.ConnectionRequest
+import proto.car.RouteDoneP.RouteDone
+import routeDoneUrl
+import java.util.*
+
+/**
+ * Created by user on 7/6/16.
+ */
+class Handler : SimpleChannelInboundHandler<Any>() {
+
+    var url: String = ""
+    var contentBytes: ByteArray = ByteArray(0);
+
+    override fun channelReadComplete(ctx: ChannelHandlerContext) {
+
+        val environment = Environment.instance
+        var success = true;
+
+        var answer:ByteArray = ByteArray(0)
+        when (url) {
+            connectUrl -> {
+                var data: ConnectionRequest? = null
+                try {
+                    data = ConnectionRequest.parseFrom(contentBytes)
+                } catch (e: InvalidProtocolBufferException) {
+                    //todo error answer
+                }
+                if (data != null) {
+                    val uid = environment.connectCar(data.ip, data.port)
+                    answer = ConnectP.ConnectionResponse.newBuilder().setUid(uid).build().toByteArray()
+                }
+            }
+            routeDoneUrl -> {
+                var data: RouteDone? = null
+                try {
+                    data = RouteDone.parseFrom(contentBytes)
+                } catch (e: InvalidProtocolBufferException) {
+                    //todo error answer
+                }
+                if (data != null) {
+                    val id = data.uid
+                    synchronized(environment.map, {
+                        val car = environment.map.get(id)
+                        if (car != null) {
+                            car.free = true
+                        } else {
+                            success = false
+                        }
+                    })
+                }
+            }
+            else -> {
+                success = false
+                //todo unsup operation. error answer
+            }
+        }
+
+        val response = DefaultFullHttpResponse(HttpVersion.HTTP_1_1, if (success) HttpResponseStatus.OK else HttpResponseStatus.NOT_FOUND, Unpooled.copiedBuffer(answer))
+        response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, response.content().readableBytes())
+        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+    }
+
+    override fun channelRead0(ctx: ChannelHandlerContext, msg: Any) {
+        if (msg is HttpRequest) {
+            this.url = msg.uri()
+        }
+
+        if (msg is DefaultHttpContent) {
+            val contentsBytes = msg.content();
+            contentBytes = ByteArray(contentsBytes.capacity())
+            contentsBytes.readBytes(contentBytes)
+        }
+    }
+
+
+    override fun exceptionCaught(ctx: ChannelHandlerContext?, cause: Throwable?) {
+        println("exception")
+        cause?.printStackTrace()
+        if (ctx != null) {
+            ctx.close()
+        }
+    }
+}

server/src/car/server/Initializer.kt

@@ -0,0 +1,31 @@
+package car.server
+
+import io.netty.channel.ChannelInitializer
+import io.netty.channel.ChannelPipeline
+import io.netty.channel.socket.SocketChannel
+import io.netty.handler.codec.http.HttpRequestDecoder
+import io.netty.handler.codec.http.HttpResponseEncoder
+import io.netty.handler.codec.http.HttpServerCodec
+import io.netty.util.concurrent.DefaultEventExecutorGroup
+import io.netty.util.concurrent.EventExecutorGroup
+
+/**
+ * Created by user on 7/6/16.
+ */
+class Initializer : ChannelInitializer<SocketChannel> {
+
+    val group: EventExecutorGroup;
+
+    constructor(handlerThreadCount: Int) {
+        this.group = DefaultEventExecutorGroup(handlerThreadCount)
+    }
+
+    override fun initChannel(channel: SocketChannel) {
+        val p: ChannelPipeline = channel.pipeline()
+
+        p.addLast(HttpServerCodec())
+//        p.addLast(HttpRequestDecoder())
+//        p.addLast(HttpResponseEncoder())
+        p.addLast(group, Handler())
+    }
+}

server/src/objects/Car.kt

@@ -1,21 +1,31 @@
 package objects
 
+import car.client.Client
+
 /**
  * Created by user on 7/7/16.
  */
 class Car constructor(id: String, host: String, port: Int) {
 
-    private val id: String
+    val id: String
-    private val host: String
+    val host: String
-    private val port: Int
+    val port: Int
 
-    var free:Boolean
+    var free: Boolean
+
+    var x: Double
+    var y: Double
 
     init {
         this.id = id
         this.host = host
         this.port = port
         this.free = true
+        x = 0.toDouble()
+        y = 0.toDouble()
     }
 
+    override fun toString(): String {
+        return "$id ; x:$x; y:$y"
+    }
 }

server/src/objects/Environment.kt

@@ -1,5 +1,7 @@
 package objects
 
+import java.util.*
+
 /**
  * Created by user on 7/7/16.
  */
@@ -16,5 +18,22 @@ class Environment private constructor() {
         map = mutableMapOf();
     }
 
+    @Synchronized
+    fun connectCar(host:String, port:Int):String {
+        //todo учетка памяти, тут машинки добавляются,но никогда не удаляются. Если включать и выключать одну и ту же машинку, то либо сервер зациклится, либо out of memory
+        //todo в зависимости от того, что кончится раньше, память или айдишники:) Может сделать поток, который мониторит раз в N минут все машинки и дропает те, которые не активны более какого-то времени?
+        var unique = false
+        val random = Random()
+        var stringUid = ""
+        while (!unique) {
+            stringUid = "id:" + random.nextInt(1000000)
+            if (map.get(stringUid) == null) {
+                unique = true;
+            }
+        }
+        map.put(stringUid, Car(stringUid, host, port))
+        return stringUid
+    }
+
 
 }

server/src/server/Server.kt

@@ -1,44 +0,0 @@
-package server
-
-import io.netty.bootstrap.ServerBootstrap
-import io.netty.channel.nio.NioEventLoopGroup
-import io.netty.channel.socket.nio.NioServerSocketChannel
-import io.netty.handler.logging.LogLevel
-import io.netty.handler.logging.LoggingHandler
-
-/**
- * Created by user on 7/6/16.
- */
-class Server : Runnable {
-
-    val port: Int;
-    val handlerThreadsCount: Int;
-
-    constructor(port: Int, handlerThreadsCount: Int) {
-        this.port = port
-        this.handlerThreadsCount = handlerThreadsCount
-    }
-
-    override fun run() {
-        val bossGroup = NioEventLoopGroup(1)
-        val workerGroup = NioEventLoopGroup()
-        val b = ServerBootstrap()
-        b.group(bossGroup, workerGroup)
-                .channel(NioServerSocketChannel().javaClass)
-                .handler(LoggingHandler(LogLevel.INFO))
-                .childHandler(ServerInitializer(handlerThreadsCount))
-
-        try {
-            val channel = b.bind(port).sync().channel()
-            channel.closeFuture().sync()
-        } catch (e: InterruptedException) {
-            e.printStackTrace()
-            //todo
-        } finally {
-            bossGroup.shutdownGracefully()
-            workerGroup.shutdownGracefully()
-        }
-
-    }
-
-}

server/src/web/server/Handler.kt

@@ -0,0 +1,45 @@
+package web.server
+
+import connectUrl
+import getLocationUrl
+import io.netty.buffer.Unpooled
+import io.netty.channel.ChannelFutureListener
+import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.SimpleChannelInboundHandler
+import io.netty.handler.codec.http.*
+import io.netty.util.CharsetUtil
+import objects.Environment
+import proto.car.ConnectP.ConnectionRequest
+import proto.car.RouteDoneP
+import proto.car.RouteDoneP.RouteDone
+import routeDoneUrl
+import setRouteUrl
+import java.nio.charset.Charset
+import java.text.SimpleDateFormat
+import java.util.*
+
+/**
+ * Created by user on 7/6/16.
+ */
+class Handler : SimpleChannelInboundHandler<Any>() {
+
+    var content: StringBuilder = StringBuilder()
+
+    override fun channelReadComplete(ctx: ChannelHandlerContext) {
+
+        content.setLength(0)
+    }
+
+    override fun channelRead0(ctx: ChannelHandlerContext, msg: Any) {
+        println(msg)
+    }
+
+
+    override fun exceptionCaught(ctx: ChannelHandlerContext?, cause: Throwable?) {
+        println("exception")
+        cause?.printStackTrace()
+        if (ctx != null) {
+            ctx.close()
+        }
+    }
+}

server/src/web/server/Initializer.kt

@@ -1,17 +1,18 @@
-package server
+package web.server
 
 import io.netty.channel.ChannelInitializer
 import io.netty.channel.ChannelPipeline
 import io.netty.channel.socket.SocketChannel
 import io.netty.handler.codec.http.HttpRequestDecoder
 import io.netty.handler.codec.http.HttpResponseEncoder
+import io.netty.handler.codec.http.HttpServerCodec
 import io.netty.util.concurrent.DefaultEventExecutorGroup
 import io.netty.util.concurrent.EventExecutorGroup
 
 /**
  * Created by user on 7/6/16.
  */
-class ServerInitializer : ChannelInitializer<SocketChannel> {
+class Initializer : ChannelInitializer<SocketChannel> {
 
     val group: EventExecutorGroup;
 
@@ -21,8 +22,8 @@ class ServerInitializer : ChannelInitializer<SocketChannel> {
 
     override fun initChannel(channel: SocketChannel) {
         val p: ChannelPipeline = channel.pipeline()
-        p.addLast(HttpRequestDecoder())
+
-        p.addLast(HttpResponseEncoder())
+        p.addLast(HttpServerCodec())
-        p.addLast(group, ServerHandler())
+        p.addLast(group, Handler())
     }
 }